// 返回日期
function returnDate(timestamp, showTimeDetail = true){
    if(typeof timestamp != 'number') timestamp = Number(timestamp)
    let date = new Date(timestamp), // 时间戳为秒需*1000，时间戳为13位的话不需乘1000
        Y = date.getFullYear() + '-',
        M = (returnTimeFormatDetail(date.getMonth() + 1)) + '-',
        D = returnTimeFormatDetail(date.getDate()) + ' ',
        h = returnTimeFormatDetail(date.getHours()) + ':',
        m = returnTimeFormatDetail(date.getMinutes()) + ':',
        s = returnTimeFormatDetail(date.getSeconds());
        // console.log('date.getMinutes()', date.getMinutes())
    if(showTimeDetail){
        return Y + M + D + h + m + s;
    }
    return Y + M + D.replace(' ', '');
}

/**
 * @param {返回日期（带时分秒），可设置具体格式}
 * showTimeDetail: 是否显示时分秒
 * firstDateIntervalFormat: 年月日之间间隔格式，默认为 "-"
 * secondTimeIntervalFormat: 时分秒之间间隔格式，默认为 ":"
 * firstDateFormat: 月日时间格式，默认为true：大于9则返回原值，大于0则返回`0${值}`，等于0则返回 "00"，false时返回原值
 * secondTimeFormat: 时分秒时间格式，默认为true：大于9则返回原值，大于0则返回`0${值}`，等于0则返回 "00"，false时返回原值
 */
function returnDateAll({ timestamp = 0, showTimeDetail = true, firstDateIntervalFormat = '-', secondTimeIntervalFormat = ':', firstDateFormat = true, secondTimeFormat = true }){
    if(typeof timestamp != 'number') timestamp = Number(timestamp)
    const date = new Date(timestamp), // 时间戳为秒需*1000，为毫秒的话不需乘1000
        Y = date.getFullYear() + firstDateIntervalFormat,
        M = (firstDateFormat ? (returnTimeFormatDetail(date.getMonth() + 1)) : date.getMonth() + 1 ) + firstDateIntervalFormat,
        D = (firstDateFormat ? returnTimeFormatDetail(date.getDate()) : date.getDate()) + (showTimeDetail ? ' ' : '');
    if(showTimeDetail){
        const h = (secondTimeFormat ? returnTimeFormatDetail(date.getHours()) : date.getHours()) + secondTimeIntervalFormat,
        m = (secondTimeFormat ? returnTimeFormatDetail(date.getMinutes()) : date.getMinutes()) + secondTimeIntervalFormat,
        s = (secondTimeFormat ? returnTimeFormatDetail(date.getSeconds()) : date.getSeconds());
        return Y + M + D + h + m + s
    }
    return Y + M + D
}

// 返回时间具体格式，如0，则返回00，小于10返回`0${值}`,大于等于10则返回值
function returnTimeFormatDetail(num){
    if(num == 0){
        return '00'
    }else if(num < 10){
        return `0${num}`
    }
    return num
}

/**
 * 返回时、分
 * @param timestamp: 时间戳
 * @param separator: 时分之间的分隔线，默认为 :
 */
function returnTimeHourMin(timestamp, separator = ':'){
    if(typeof timestamp != 'number') timestamp = Number(timestamp)
    const time = new Date(timestamp),
    hour = time.getHours(),
    hourText = hour > 9 ? hour : `0${hour}`,
    minute = time.getMinutes(),
    minuteText = minute > 9 ? minute : `0${minute}`;
    return `${hourText}${separator}${minuteText}`
}

// 返回月、日
function returnMothDay(timestamp){
    if(typeof timestamp != 'number') timestamp = Number(timestamp)
    const time = new Date(timestamp),
    monthText =  `${time.getMonth() + 1}月`,
    dayText = `${time.getDate()}日`;
    return `${monthText}${dayText}`
}

// 返回开始时间距离结束时间的时长，默认分钟
function returnStartToEndTimeTime({startTime = 0, endTime = 0}){
    // console.log('startTime', startTime)
    // console.log('endTime', endTime)
    return Math.floor((endTime - startTime) / 60000)
}

// 获取北京时间
function getBeijingtime() {
    // 获得当前运行环境时间
    const d = new Date(),
    currentDate = new Date(),
    tmpHours = currentDate.getHours();
    // 算得时区
    var time_zone = -d.getTimezoneOffset() / 60;
    if (time_zone < 0) {
        time_zone = Math.abs(time_zone) + 8; currentDate.setHours(tmpHours + time_zone);
    } else {
        time_zone -= 8; currentDate.setHours(tmpHours - time_zone);
    }
    return currentDate;
}

function getTimeStamp(){
	const currentDate = getBeijingtime()
	const y = currentDate.getFullYear()   //当前客户端对应的北京时间的年
  	const m = currentDate.getMonth()   //北京时间的月
  	const d = currentDate.getDate()
  	const h = currentDate.getHours()
 	const mm = currentDate.getMinutes()
 	const ss = currentDate.getSeconds()
 	// Date.UTC() 方法接受的参数同日期构造函数接受最多参数时一样，返回从1970-1-1 00:00:00 UTC到指定日期的的毫秒数。
  	const timeObj = Date.UTC(y, m, d, h, mm, ss, 0) / 1000 - (8 * 60 * 60)
    return timeObj
}

/**
 * 返回月日，可配置格式
 * @param timestamp: 时间戳
 * @param isSingular: 为单数时是否显示单数，默认显示双数
 * @param separator: 月日之间的分隔符
 */
function returnMothDayParams({timestamp, isSingular = false, separator = ":"}){
    if(typeof timestamp != 'number') timestamp = Number(timestamp)
    const date = new Date(timestamp),
    month = date.getMonth() + 1,
    monthText = isSingular ? month : month > 9 ? month : `0${month}`,
    day = date.getDate(),
    dayText = isSingular ? day : day > 9 ? day : `0${day}`;
    return `${monthText}${separator}${dayText}`
}

/**
 * 返回周几，星期几
 * @param timestamp: 时间戳
 * @param prefixText: 前面文字，默认为周，否则为星期
 */
function returnWeekText({timestamp, prefixText = '周'}){
    if(typeof timestamp != 'number') timestamp = Number(timestamp)
    prefixText = prefixText != '周' ? '星期' : prefixText;
    const numberTextArr =['日', '一', '二', '三', '四', '五', '六'];
    return `${prefixText}${numberTextArr[new Date(timestamp).getDay()]}`
}

/**
 * 根据现在时间判断距离开始和结束时间的状态 
 * 1、未开始notStartObj  2、快开始（1小时内）soonStartObj 3、进行中underwayObj 4、已结束endStatusObj
 * @param nowTime : 现在时间戳
 * @param startTime : 开始时间戳
 * @param endTime : 结束时间戳
 * @param notStartObj : 未开始返回的参数对象
 * @param soonStartObj : 快开始返回的参数对象
 * @param underwayObj : 进行中返回的参数对象
 * @param endStatusObj : 已结束返回的参数对象
 */
function setStatusFromStartEndTime({nowTime = new Date().getTime(), startTime = 0, endTime = 0, notStartObj = {}, soonStartObj = {}, underwayObj = {}, endStatusObj = {}}){
    if(nowTime - endTime > 0){ // 已结束
        return endStatusObj
    }else{
        if(nowTime > startTime && nowTime < endTime){ // 已开始
            return underwayObj
        }else{ // 未开始
            const fromBeginningTime = startTime - nowTime, // 距离开始的时间戳
            fromBeginningTimeHour = Math.floor(fromBeginningTime * 0.0000002778); // 距离开始的时间，以小时为单位
            // console.log('距离开始的时间戳 fromBeginningTime:', fromBeginningTime)
            // console.log('距离开始的时间，以小时为单位 fromBeginningTimeHour:', fromBeginningTimeHour)
            if(fromBeginningTimeHour >= 1){ // 离开始有一小时以上
                if(fromBeginningTimeHour > 24){ // 离开始有一天以上
                    const newNotStartObj = Object.assign({}, notStartObj)
                    newNotStartObj.unit = 'day'
                    newNotStartObj.unitText = '天'
                    newNotStartObj.count = Math.floor(fromBeginningTimeHour / 24)
                    return newNotStartObj
                }else{ // 离开始一天以内
                    const newNotStartObj = Object.assign({}, notStartObj)
                    newNotStartObj.unit = 'hour'
                    newNotStartObj.unitText = '小时'
                    newNotStartObj.count = fromBeginningTimeHour
                    return newNotStartObj
                }
            } else { // 1小时以内
                const newSoonStartObj = Object.assign({}, soonStartObj)
                newSoonStartObj.count = Math.floor(fromBeginningTime * 0.0000167)
                newSoonStartObj.unit = 'minute'
                newSoonStartObj.unitText = '分钟'
                return newSoonStartObj
            }
        }
    }   
}

//转换UTC时间为本地时间,兼容 ios/Android/PC
export function convertUTCTimeToLocalTime(UTCDateString) {
    // console.log(UTCDateString);
    if (!UTCDateString) {
        return '-';
    };
    function formatFunc(str) {    //格式化显示
        return str > 9 ? str : '0' + str;
    };
    let date2 = '';
    if (Number(UTCDateString)) {
        date2 = new Date(UTCDateString);
    } else {
        if(typeof UTCDateString == 'object'){
            date2 = UTCDateString;
        }else{
            date2 = new Date(UTCDateString.replace('T', ' ').replace('-', '/').replace('-', '/'));
        }
    }
    const year = date2.getFullYear(),
        mon = formatFunc(date2.getMonth() + 1),
        day = formatFunc(date2.getDate());
    let hour = date2.getHours();
    const secondss = formatFunc(date2.getSeconds());
    hour = formatFunc(hour);
    let min = formatFunc(date2.getMinutes());
    const dateStr = year + '-' + mon + '-' + day + ' ' + hour + ':' + min + ':' + secondss;
    return dateStr;
}

/**
* 将时间戳转换为，几周前，几天前，几分钟前的形式。
* @param timestamp: 时间戳
*/
export function returnLastTime(timestamp) {
   const minute = 1000 * 60,
   hour = minute * 60,
   day = hour * 24,
   month = day * 30,
   now = new Date().getTime(),
   diffValue = now - timestamp,
   monthC = diffValue / month,
   weekC = diffValue / (7 * day),
   dayC = diffValue / day,
   hourC = diffValue / hour,
   minC = diffValue / minute;
   let result = '刚刚';
   if (monthC >= 1) {
       result = "" + parseInt(monthC) + "月前"
   } else if(weekC >= 1){
       result = "" + parseInt(weekC) + "周前"
   } else if(dayC >= 1){
       result = "" + parseInt(dayC) + "天前"
   } else if(hourC >= 1){
       result = "" + parseInt(hourC) + "小时前"
   } else if(minC >= 1){
       result = "" + parseInt(minC) + "分钟前"
   }
   return result
}

/**
* 如果为月内，将时间戳转换为，几周前，几天前，几分钟前的形式。
* 否则返回具体时间
* @param timestamp: 时间戳
* @param prefixText: 前面文字，默认为周，否则为星期
* @param showTimeDetail: 是否显示时分秒
* @param firstDateIntervalFormat: 年月日之间间隔格式，默认为 "-"
* @param secondTimeIntervalFormat: 时分秒之间间隔格式，默认为 ":"
* @param firstDateFormat: 月日时间格式，默认为true：大于9则返回原值，大于0则返回`0${值}`，等于0则返回 "00"，false时返回原值
* @param secondTimeFormat: 时分秒时间格式，默认为true：大于9则返回原值，大于0则返回`0${值}`，等于0则返回 "00"，false时返回原值
* @param showLastTime: Bollean, 是否显示几周前，几天前，几分钟前的形式。
*/
export function returnTime({
    timestamp, 
    showTimeDetail = true, 
    firstDateIntervalFormat = '-', 
    secondTimeIntervalFormat = ':', 
    firstDateFormat = true, 
    secondTimeFormat = true,
    showLastTime = true,
}){
    if (typeof timestamp != 'number') timestamp = Number(timestamp)
    // console.log('(new Date().getTime() - timestamp) / (86400000 * 30):', (new Date().getTime() - timestamp) / (86400000 * 30))
    // console.log('时间', returnDateAll({timestamp}))
    if (showLastTime) {
        if ((new Date().getTime() - timestamp) / (86400000 * 30) >= 1) { // 如果大于一个月，显示具体时间
            return returnDateAll({timestamp, showTimeDetail, firstDateIntervalFormat, secondTimeIntervalFormat, firstDateFormat, secondTimeFormat})
        } else { // 否则显示几周前、几天前
            return returnLastTime(timestamp)
        }
    } else {
        return returnDateAll({timestamp, showTimeDetail, firstDateIntervalFormat, secondTimeIntervalFormat, firstDateFormat, secondTimeFormat})
    }
}

export { returnDate, returnTimeHourMin, returnStartToEndTimeTime, returnMothDay, getTimeStamp, returnTimeFormatDetail, returnDateAll, returnMothDayParams, returnWeekText,
    setStatusFromStartEndTime }